package com.ruoyi.manager.service.impl;

import java.util.ArrayList;
import java.util.List;

import javax.annotation.Resource;

import com.basic.service.impl.BaseServiceImpl;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.constant.RedisConstant;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.ListOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import com.ruoyi.manager.mapper.MgServiceTypeMapper;
import com.ruoyi.manager.domain.MgServiceType;
import com.ruoyi.manager.service.IMgServiceTypeService;
import com.translate.mapper.IBaseMapper;

/**
 * 服务类型 不存在增删改Service业务层处理
 * 
 * @author ruoyi
 * @date 2023-12-13
 */
@Service
public class MgServiceTypeServiceImpl extends BaseServiceImpl<Long, MgServiceType> implements IMgServiceTypeService 
{
    public MgServiceTypeServiceImpl(MgServiceTypeMapper baseMapper) {
		super(baseMapper);
		// TODO Auto-generated constructor stub
	}

    private RedisTemplate<String, MgServiceType> redisTemplate;
    
    
    

    /**
     * 查询服务类型 不存在增删改
     * 
     * @param id 服务类型 不存在增删改主键
     * @return 服务类型 不存在增删改
     */
    @Override
    public MgServiceType selectMgServiceTypeById(Integer id)
    {
        return baseMapper.selectById(id);
    }

    /**
     * 查询服务类型 不存在增删改列表
     * 
     * @param mgServiceType 服务类型 不存在增删改
     * @return 服务类型 不存在增删改
     */
    @Override
    public List<MgServiceType> selectMgServiceTypeList(MgServiceType mgServiceType)
    {
    	
    	HashOperations<String, String, MgServiceType> operations = redisTemplate.opsForHash();
    	
    	List<MgServiceType> values = operations.values(RedisConstant.SERVICE_MANAGER_KEY);
//    	
    	if (null != values && 0 != values.size()) {
    		return values;
    	}
    	
        List<MgServiceType> selectMgServiceTypeList = baseMapper.selectList(mgServiceType);
        
        for (MgServiceType item : selectMgServiceTypeList) {
			
        	operations.put(RedisConstant.SERVICE_MANAGER_KEY, item.getId().toString(), item);
		}
        
		return selectMgServiceTypeList;
    }
    
    public MgServiceType geterviceType(long typeId) {
    	
    	HashOperations<String, String, MgServiceType> operations = redisTemplate.opsForHash();
    	
    	return operations.get(RedisConstant.SERVICE_MANAGER_KEY, typeId+"");
    	
    	
    }

    /**
     * 新增服务类型 不存在增删改
     * 
     * @param mgServiceType 服务类型 不存在增删改
     * @return 结果
     */
    @Override
    public int insertMgServiceType(MgServiceType mgServiceType)
    {
        
        return baseMapper.insert(mgServiceType);
    }

    /**
     * 修改服务类型 不存在增删改
     * 
     * @param mgServiceType 服务类型 不存在增删改
     * @return 结果
     */
    @Override
    public int updateMgServiceType(MgServiceType mgServiceType)
    {
        return baseMapper.update(mgServiceType);
    }

    /**
     * 批量删除服务类型 不存在增删改
     * 
     * @param ids 需要删除的服务类型 不存在增删改主键
     * @return 结果
     */
    @Override
    public int deleteMgServiceTypeByIds(Integer[] ids)
    {
        return baseMapper.deleteByIds(ids);
    }

    /**
     * 删除服务类型 不存在增删改信息
     * 
     * @param id 服务类型 不存在增删改主键
     * @return 结果
     */
    @Override
    public int deleteMgServiceTypeById(Integer id)
    {
        return baseMapper.deleteById(id);
    }

    @Resource
	public void setRedisTemplate(RedisTemplate<String, MgServiceType> redisTemplate) {
		this.redisTemplate = redisTemplate;
	}

	@Override
	public List<MgServiceType> selectMgServiceTypeTranslateList() {
		
		List<MgServiceType> serviceTypes = new ArrayList<MgServiceType>();
		
		List<MgServiceType> selectMgServiceTypeList = this.selectMgServiceTypeList(new MgServiceType());
//		
		for (MgServiceType mgServiceType : selectMgServiceTypeList) {
			
			Integer id = mgServiceType.getId();
			
			if (8 == id ) {
				serviceTypes.add(mgServiceType);
			}
			
		}
		return selectMgServiceTypeList;
	}
}
